<!doctype html>
<html lang="zh-cn">
  <head>
    <title>Python--函数(二) // JW Blog</title>
    <meta charset="utf-8" />
    <meta name="generator" content="Hugo 0.60.1" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="author" content="John Doe" />
    <meta name="description" content="" />
    <link rel="stylesheet" href="https://duyi111.gitee.io/css/main.min.f90f5edd436ec7b74ad05479a05705770306911f721193e7845948fb07fe1335.css" />

    
    <meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content="Python--函数(二)"/>
<meta name="twitter:description" content="[toc]
1.局部变量和全局变量 1.1局部变量  概念: 定义一个函数内部的变量称为局部变量 作用域(使用范围): 在函数内部使用 注意:  定义在不同的函数内部有相同名字的局部变量是不影响的,因为他们所处不同的作用域    1.2全局变量  概念: 定义在函数外部的变量称为全局变量 作用域: 在整个模块中 场景  1 #全局变量 a = 10 def func(): #局部变量 a = 20  2 #全局变量 a = 10 def func(): global a #利用函数修改全局变量 a = 20  3 def func(): #利用一个函数定义一个全局变量 global a a = 10     2.多个函数中共享数据的方式  使用全局变量 使用函数的返回值, 参数 函数嵌套使用  3.函数的返回值(二) 3.1.多个return  总结:  即使在函数内部有多个return,只要有一个执行后,其后面的代码将都不再执行 如果一个函数中出现return数值  标识着函数是有返回值的函数 提前结束函数的调用      3."/>

    <meta property="og:title" content="Python--函数(二)" />
<meta property="og:description" content="[toc]
1.局部变量和全局变量 1.1局部变量  概念: 定义一个函数内部的变量称为局部变量 作用域(使用范围): 在函数内部使用 注意:  定义在不同的函数内部有相同名字的局部变量是不影响的,因为他们所处不同的作用域    1.2全局变量  概念: 定义在函数外部的变量称为全局变量 作用域: 在整个模块中 场景  1 #全局变量 a = 10 def func(): #局部变量 a = 20  2 #全局变量 a = 10 def func(): global a #利用函数修改全局变量 a = 20  3 def func(): #利用一个函数定义一个全局变量 global a a = 10     2.多个函数中共享数据的方式  使用全局变量 使用函数的返回值, 参数 函数嵌套使用  3.函数的返回值(二) 3.1.多个return  总结:  即使在函数内部有多个return,只要有一个执行后,其后面的代码将都不再执行 如果一个函数中出现return数值  标识着函数是有返回值的函数 提前结束函数的调用      3." />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://duyi111.gitee.io/post/%E5%87%BD%E6%95%B02/" />
<meta property="article:published_time" content="2020-01-09T20:41:14+08:00" />
<meta property="article:modified_time" content="2020-01-09T20:41:14+08:00" />


  </head>
  <body>
    <header class="app-header">
      <a href="https://duyi111.gitee.io/"><img class="app-header-avatar" src="/avatar.jpg" alt="John Doe" /></a>
      <h1>JW Blog</h1>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc vehicula turpis sit amet elit pretium.</p>
      <div class="app-header-social">
        
      </div>
    </header>
    <main class="app-container">
      
  <article class="post">
    <header class="post-header">
      <h1 class ="post-title">Python--函数(二)</h1>
      <div class="post-meta">
        <div>
          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="icon icon-calendar">
  <title>calendar</title>
  <rect x="3" y="4" width="18" height="18" rx="2" ry="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line>
</svg>
          Jan 9, 2020
        </div>
        <div>
          <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="icon icon-clock">
  <title>clock</title>
  <circle cx="12" cy="12" r="10"></circle><polyline points="12 6 12 12 16 14"></polyline>
</svg>
          2 min read
        </div></div>
    </header>
    <div class="post-content">
      <p>[toc]</p>
<h2 id="1">1.局部变量和全局变量</h2>
<h4 id="11">1.1局部变量</h4>
<ul>
<li>概念: 定义一个函数内部的变量称为局部变量</li>
<li>作用域(使用范围): 在函数内部使用</li>
<li>注意:
<ul>
<li>定义在不同的函数内部有相同名字的局部变量是不影响的,因为他们所处不同的作用域</li>
</ul>
</li>
</ul>
<h4 id="12">1.2全局变量</h4>
<ul>
<li>概念: 定义在函数外部的变量称为全局变量</li>
<li>作用域: 在整个模块中</li>
<li>场景
<ul>
<li>1
<pre><code>#全局变量
a = 10
def func():
    #局部变量
    a = 20
</code></pre></li>
<li>2
<pre><code>#全局变量
a = 10
def func():
    global a
    #利用函数修改全局变量
    a = 20
</code></pre></li>
<li>3
<pre><code>def func():
#利用一个函数定义一个全局变量
global a
a = 10
</code></pre></li>
</ul>
</li>
</ul>
<h2 id="2">2.多个函数中共享数据的方式</h2>
<ul>
<li>使用全局变量</li>
<li>使用函数的返回值, 参数</li>
<li>函数嵌套使用</li>
</ul>
<h2 id="3">3.函数的返回值(二)</h2>
<h4 id="31return">3.1.多个return</h4>
<ul>
<li>总结:
<ul>
<li>即使在函数内部有多个return,只要有一个执行后,其后面的代码将都不再执行</li>
<li>如果一个函数中出现return数值
<ul>
<li>标识着函数是有返回值的函数</li>
<li>提前结束函数的调用</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4 id="32">3.2.一个函数返回多个数据的方式</h4>
<ul>
<li>如果想利用函数一次返回多个数值
<pre><code>def func():
    pass
    return 数值1, 数值2, ...
ret = func()
#ret默认就是元组类型
</code></pre></li>
<li>总结
<ul>
<li>return后面可以是元组, 列表, 字典等,只要是能够存储多个数据的类型,就可以一次性返回多个数据</li>
<li>如果return后面有多个数据,那么默认是元组</li>
</ul>
</li>
</ul>
<h2 id="4">4.函数的调用方式总结</h2>
<ul>
<li>函数的定义
<pre><code>def func(a, b):
    pass
</code></pre></li>
<li>函数的调用
<ul>
<li>位置参数调用(个数统一,位置一一对应)
<pre><code>func(实参1, 实参2, )
</code></pre></li>
<li>关键字参数调用(个数统一,形参名要书写正确,不强调顺序)
<pre><code>func(a = 实参1, b = 实参2)
</code></pre></li>
</ul>
</li>
<li>补充: 定义一个函数只能使用关键字参数调用
<pre><code>def func(*, a, b):
    pass
</code></pre></li>
</ul>
<h2 id="5">5.函数的参数(二)</h2>
<h4 id="51">5.1缺省参数</h4>
<ul>
<li>概念: 如果一个函数有参数,而且参数有默认值,就称为缺省参数</li>
<li>格式:
<pre><code>def func(a = 10):
    pass
</code></pre></li>
<li>特点:
<ul>
<li>假如调用函数的时候,对应形参的位置没有传入实参,那么将使用默认值</li>
<li>假如调用函数的时候,对应形参的位置传入实参,那么实参将会把默认值覆盖</li>
</ul>
</li>
<li>注意点:
<ul>
<li>默认情况下,如果函数中出现了缺省参数,其缺省参数后面的参数必须是缺省参数,++<strong>即带有默认值的参数一定要位于参数列表的最后面</strong>++</li>
</ul>
</li>
</ul>
<h4 id="52">5.2不定长参数</h4>
<ul>
<li>有时可能需要一个函数能处理比当初声明时更多的参数,这些参数叫做<strong>不定长参数</strong>,声明时不会命名.</li>
<li>加了星号(*)的变量args会存放所有未命名的变量参数,args为元组</li>
<li>加**的变量kwargs会存放命名参数,即形如key=value的参数,kwargs为字典</li>
<li>相同点
<ul>
<li>定义一个有参数的函数</li>
<li>调用函数的时候,不确定到底传入多少个实参</li>
</ul>
</li>
<li>不同点
<ul>
<li>元组
<ul>
<li>位置参数调用函数</li>
<li>函数内部是利用下标索引获取实参数据</li>
</ul>
</li>
<li>字典
<ul>
<li>关键字参数调用函数</li>
<li>函数内部是利用key获取实参的数据</li>
</ul>
</li>
</ul>
</li>
<li>格式
<ul>
<li>元组
<pre><code>def func(*args):
    pass
</code></pre></li>
<li>字典
<pre><code>def func(**kwargs):
    pass
</code></pre></li>
</ul>
</li>
<li>注意点
<ul>
<li>无论不定长参数元组还是字典,都是缺省参数,其默认值为空的元组和字典</li>
<li>如果很多个值都是不定长参数,那么在这种情况下可以将缺省参数放到*args的后面,但如果有**kwargs的话,**kwargs必须放到最后</li>
</ul>
</li>
</ul>
<h2 id="6">6.函数的定义参数总结</h2>
<ul>
<li>顺序
<ul>
<li>标准参数</li>
<li>缺省参数</li>
<li>不定长参数元组</li>
<li>不定长参数字典</li>
</ul>
</li>
<li>注意:
<ul>
<li>不定长参数字典的<code>key</code>的名字不要和其他形参名字冲突</li>
</ul>
</li>
</ul>
<h2 id="7-2">7.拆包, 交换2个变量的值</h2>
<h4 id="71">7.1拆包</h4>
<ul>
<li>拆包
<pre><code>变量1, 变量2, = 容器类型
</code></pre><ul>
<li>str, list, tuple, dict, set</li>
</ul>
</li>
<li>组包
<pre><code>变量名 = 数值1, 数值2, ...
变量最终为元组类型
</code></pre></li>
<li>注意
<ul>
<li>拆包时要注意,需要拆的数据的个数要与变量的个数相同</li>
<li>对字典拆包的时候,取出来的是<code>key</code>,而不是键值对</li>
</ul>
</li>
</ul>
<h4 id="722">7.2交换2个变量的值</h4>
<ul>
<li>方法一
<pre><code>a = 1
b = 2
c = 0
  
c = a
a = b
b = c
  
print(a)
print(b)
</code></pre></li>
<li>方法二
<pre><code>a = 1
b = 2
  
a = a + b  # a=3, b=2
b = a - b  # a=3, b=1
a = a - b  # a=2, b=1
  
print(a)
print(b)
</code></pre></li>
<li>方法三
<pre><code>a, b = 1, 2
a, b = b, a
  
print(a)
print(b)
</code></pre></li>
</ul>
<h2 id="8">8.可变,不可变类型</h2>
<ul>
<li>分类
<ul>
<li>不可变类型
<ul>
<li>str</li>
<li>tuple</li>
</ul>
</li>
<li>可变类型
<ul>
<li>list</li>
<li>dict</li>
<li>set</li>
</ul>
</li>
</ul>
</li>
<li>如何判断是否是可变和不可变类型
<ul>
<li>试着修改该数据的数据结构,如果成功标识着是可变的数据类型</li>
</ul>
</li>
</ul>
<h2 id="9">9.引用</h2>
<ul>
<li>在python中,值是靠引用来传递的,我们可以将id值理解为那块内存的地址标识</li>
<li>不可变类型
<ul>
<li>如果进行了重新赋值id会发生改变</li>
</ul>
</li>
<li>可变类型
<ul>
<li>如果进行了重新赋值id会发生改变</li>
<li>如果对原来的数据进行增加或者删除或者修改,id不会发生改变,因为操作的还是那个地址空间的数据</li>
</ul>
</li>
<li>id()函数
<ul>
<li>用来查看一个变量或者数值在内存中的唯一标识</li>
</ul>
</li>
<li>注意:
<ul>
<li>调用一个有参数的函数的时候,其传递的是引用而非数值</li>
<li>不可变数据类型
<ul>
<li>无论是b += b 还是b = b + b都是重新赋值</li>
</ul>
</li>
<li>可变数据类型
<ul>
<li>b += b是对原来的数据进行修改</li>
<li>b = b + b是重新赋值</li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="10">10.递归函数</h2>
<ul>
<li>概念:函数自己调用自己</li>
<li>书写递归函数的步骤:
<ul>
<li>定义一个函数有参数</li>
<li>在函数体内自己调用自己(参数呈现递增或者递减的变化)</li>
<li>为了满足需求执行的代码</li>
<li>停止递归调用的条件</li>
</ul>
</li>
<li>注意:
<ul>
<li>在python中书写递归要有停止递归调用的条件,如果没有,程序将报错</li>
</ul>
</li>
</ul>
<h2 id="111">11.匿名函数</h2>
<ul>
<li>使用lambda定义的函数,称为匿名函数</li>
<li>格式:
<pre><code>匿名函数名 = lambda 形参1, 形参2, ... :表达式或者函数调用
</code></pre></li>
<li>注意点:
<ul>
<li>不是所有的标准函数都可以通过匿名函数实现</li>
<li>标准函数是一个代码块,匿名函数是一个表达式</li>
<li>匿名函数用于把简单的标准函数通过匿名函数实现</li>
<li>可以作为函数的参数传递</li>
</ul>
</li>
</ul>
<h2 id="121">12.列表推导式</h2>
<ul>
<li>概念: 通过列表推导式轻量级循环遍历创建列表</li>
<li>格式(举例):
<ul>
<li>[1, 2, 3, 4, 5]
<pre><code>list = [i for i in range(1, 6)]
</code></pre></li>
<li>[&lsquo;哈哈&rsquo;, &lsquo;哈哈&rsquo;, &lsquo;哈哈&rsquo;]
<pre><code>list = ['哈哈' for _ in range(3)]
</code></pre></li>
<li>[2, 4, 6, 8, 10]
<pre><code>list = [i for i in range(1, 11) if i % 2 == 0]
</code></pre></li>
<li>[(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3)]
<pre><code>list = [(i, j) for i in range(2) for j in range(1, 3)]
</code></pre></li>
</ul>
</li>
</ul>

    </div>
    <div class="post-footer">
      
    </div>
  </article>

    </main>
  </body>
</html>
